#ifndef Conj_H
#define Conj_H

#include "Secuencia.h"
//#include "tiposBasicos.h"

#include <iostream>
typedef unsigned long int nat;
using namespace std;

template <class T1> class iterConj;
template <class T2> class Secuencia;
template <class T> class Conj{
         public:

         friend class iterConj<T>;

                //Constructores y destructores
                Conj(void);
                Conj(const Conj<T> &c);
                ~Conj(void);

                //funciones publicas
                void ag(T elem);
                void quitar(const T &elem);
                void sinUno(void);
                T& dameUno(void);
                bool pertenece(const T &elem);
                bool estaVacio(void);
                nat cantelem(void) const;
                void operator=(const Conj<T> &c);
                bool operator==(const Conj<T> &c) const;
                bool operator!=(const Conj<T> &c) const;
                template<class T2> friend ostream & operator<<(ostream &out, const Conj<T2> &m);

         private:
                 Secuencia<T> s;

};



template<class T> Conj<T>::Conj(void){
         s;
}

template<class T> Conj<T>::Conj(const Conj<T> &c) {
               s = c.s;
}

template<class T> Conj<T>::~Conj(void){
               while(s.tamano() > 0){
               s.fin();
               }
}

template<class T> void Conj<T>::ag(T elem){
               if (!(s.esta(elem))){
                  s.agregarOrdenado(elem);
               }
}

template<class T> void Conj<T>::quitar(const T &elem){
                   s.quitar(elem);
}

template<class T> void Conj<T>::sinUno(void){
                  s.fin();
}

template<class T> T & Conj<T>::dameUno(void){
               return s.primero();
               }

template<class T> bool Conj<T>::estaVacio(void){
               return s.vacia();
               }

template<class T> bool Conj<T>::pertenece(const T &elem){
               return s.esta(elem);
               }

template<class T> nat Conj<T>::cantelem(void) const{
               return s.tamano();
               }

template<class T> bool Conj<T>::operator==(const Conj<T> &c) const {
               return s == c.s;
}

template<class T> bool Conj<T>::operator!=(const Conj<T> &c) const {
               return s != c.s;
}

template<class T> void Conj<T>::operator=(const Conj<T> &c){
               s = c.s;
}

template<class T2> ostream & operator<<(ostream &out, const Conj<T2> &m) {
               out << m.s;
               return out;
               }

#endif
